<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>数组</title>
</head>

<body>
    <script>
        /*
        //方法一：字面量(直接量)
        //let num = 1;
        let cars = ["Baoma", "Yema", "Baoshijie"];
        console.log(cars);

        //方法二：new操作符
        let myCars = new Array();
        console.log(myCars);
        myCars[0] = "Baoma";
        myCars[1] = "Baoshijie";
        myCars[3] = "兰博基尼";
        */

        /*
        let cars = ["baoma", "baoshijie", "lanbojini"];
        console.log(cars[0], cars[3]);//baoma undefined
        */

        /*
        let arr = [1, "czh", { name: "people", age: 22 }, function () {
            console.log("我是函数");
        },
        ];
        */

        /*
        let arr = [];
        arr[0] = 1;
        arr[1] = 2;
        arr[2] = 2;

        console.log(arr);
        //[1,2,2]
        */

        /*
        let arr = [];
        arr[0] = "a";
        arr[1] = "b";
        arr[2] = "c";

        console.log(arr.length);
        //[1,2,2]
        */

        /*
        let arr = [1, 2, 3, 4];
        console.log(arr.length);
        //4
        arr[9] = 9;
        console.log(arr);
        //中间出现empty*5
        console.log(arr.length);
        //9+1=10
        console.log(arr[7]);
        //undefined
        arr.length = 3;
        console.log(arr);
        */

        /*
        let arr = [1, 2, 3, "a"];
        console.log(arr.indexOf("a"));
        console.log(arr.indexOf(5));
        //-1 (如果数组内没有该元素，则返回-1)
        */

        /*
        let arr = [1, 2];
        arr[arr.length] = 3;
        console.log(arr);
        arr[arr.length] = 4;
        console.log(arr);
        */

        // ##8
        /*
        let arr = [1, 2, 3, 4];
        for (let i = 0; i < arr.length; i++) {
            console.log(arr[i]);
        } 
        */

        /*
        forEach()方法需要一个函数作为参数

        像这种函数，由我们创建但不由我们调用，这种称之为回调函数(callback)

        数组中有几个元素函数就会执行几次
        
        每次执行的时候都会将遍历到的元素以实参(实际参数)的形式传递进来

        可以在函数中定义形参(形式参数)来接受实参(实际参数)

        forEach()方法会在我们写的回调函数传入三个参数
        第一个参数：当前正在遍历的元素
        第二个参数：当前正在遍历的元素的索引
        第三个参数：正在遍历的数组

        let arr = [{}, 1, 2, 3, 4];
        arr.forEach(function (val, index, el) {
            console.log(val, index, el);
        }); 
        */

        //把arr数组中的对象数据age大于18的对象取出来，放到一个新数组里面去
        /* 
        88let arr = [
            { name: "czh", age: 17 },
            { name: "jack", age: 38 },
            { name: "alex", age: 100 },
            { name: "abin", age: 20 },
        ];
        let newArr = [];
        for (let i = 0; i < arr.length; i++) {
            if (arr[i].age >= 18) {
                newArr[newArr.length] = arr[i]
            }
        }
        console.log(newArr);
        */

        /*
        let arr = [1, 2, 3];
        let l = arr.push(4, 5, 6);
        console.log(arr);
        //[1,2,3,4,5,6]
        console.log(l, arr.length);
        //6,6 
        */

        /*
        let arr = [1, 2, 8];
        let res = arr.pop();//8
        console.log(res);//8
        console.log(arr);//[1,2] 
        */

        /*
        let arr = [1, 2, 3];
        let l = arr.unshift(8);
        console.log(arr, l);
        //[8,1,2,3],4
        */

        /*
        let arr = [8, 2, 3];
        let l = arr.shift();
        console.log(arr, l);
        //[2,3]8
        */

        //练习
        //把去重后的数组赋予newArr
        /* 
        let arr = [1, 2, 3, 1, 2, 3, 1, 2, 4, 5, 6];
        let newArr = [];
        // indexOf()
        //遍历旧数组
        for (let i = 0; i < arr.length; i++) {
            //判断arr[i]的值是否存在在新数组中，如果不存在则添加进去
            if (newArr.indexOf(arr[i]) === -1) {
                newArr.push(arr[i]);
            }
        }
        console.log(arr);
        console.log(newArr);
        */

        /* 
        slice()方法
        该方法不会改变原数组，而是将截取到的元素封装到一个新数组中返回
        - 该方法有两个参数
            - 第一个参数:截取开始的位置的索引(下标)
            - 第二个参数:截取结束的位置的索引，不包含结束的索引值的元素
            (第二个参数可以不传，此时就会截取从开始索引到后面的所有元素)
            (如果第二个参数为负数)
            -1:倒数第一个
            -2:倒数第二个
        如果第二个参数小于等于第一个参数下标的绝对值，那截取出来的数组就是空数组
        */
        /*
        let arr = [1, 2, 3, 4, 5, 6];
        let newArr = arr.slice(1, 4);
        console.log(newArr);//[2, 3, 4]
        console.log(arr);//[1, 2, 3, 4, 5, 6]

        newArr = arr.slice(1);
        console.log(newArr);//[2,3,4,5,6]

        newArr = arr.slice(1, -1);
        console.log(newArr);//[2, 3, 4, 5]

        newArr = arr.slice(3, 1);
        console.log(newArr);//[](空数组)

        newArr.slice(-2, -1);
        console.log(newArr);//[] 
        */

        /* 
        splice()会影响到元素组，会将指定元素从数组中删除，并将删除的元素作为返回值
        参数:
            第一个参数:要删除的元素开始的位置索引
                如果只传第一个参数，那么会把开始位置的元素到后面的所有元素全部删除
            第二个参数:要删除的数量
                如果第二个参数小于或等于0；那就是没有删除
            第三个参数以及更多参数:将这些参数插入到开始位置的索引前面
        */

        /*
        let arr = [1, 8, 3, 4, 5,];
        let newArr = arr.splice(1, 1, "a", "b", "c");
        console.log(newArr, arr);
        //8 [1,2,3,4,5,'a','b','c']
        */

        /* let arr = [1, 2, 3, 4, 1, 23, 1];
        //获取数组中的每个元素
        for (let i = 0; i < arr.length; i++) {
            //获取当前元素后面的所有元素
            for (let j = i + 1; j < arr.length; j++) {
                //进行比较并去重(splice删除)
                if (arr[i] == arr[j]) {
                    arr.splice(j, 1);
                    //删除当前j所在的元素后，后面的元素会自动补位
                    //此时将不会在比较这个元素，这时我们需要手动把j往前调
                    j--;
                }
            }
        }
        console.log(arr);

        //第三种去重
        let arr1 = [1, 2, 3, 5, 6, 4, 3, 2, 1, 1, 2, 3, 4, 5];
        let newArr = Array.from(new Set(arr1));
        console.log(newArr);
        */

        /* 
        concat()是可以连接多个数组并将连接后的新组数返回,
        该方法不会改变原数组
        */
        /*
        let arr = [1, 2, 3];
        let arr1 = [4, 5, 6];
        let arr2 = [7, 8, 9];
        let res = arr.concat(arr1, arr2, "xx", "hh");
        console.log(res, arr);
        */

        /* 
        join()方法将数组转换成字符串
            该方法不会影响原数组，而是将转换后的字符串作为结果返回
            在join()中可以指定一个字符串作为参数，这个字符串将会成为数组中元素的连接符号
            如果不指定连接符，则默认使用逗号作为连接符号
        */
        /*
        let arr = [1, 2, 3];
        let res = arr.join("-");
        console.log(res, arr);
        */

        /* 
        reverse()方法会修改原数组,返回反转后的数组,该方法用来反转数组元素的顺序
        */
        /*
        let arr = [1, 2, 3, 4];
        let res = arr.reverse();
        console.log(arr, res);
        */

        let arr = [];
        let arr1 = "czh";
        console.log(Array.isArray(arr), Array.isArray(arr1));
    </script>
</body>

</html>